// pages/user-time-tasks/user-time-tasks.js
const app = getApp()

Page({
  data: {
    timeTasks: [],
    loading: false,
    currentTask: null,
    showStartModal: false,
    showEndModal: false,
    showReportModal: false,
    startTime: '',
    endTime: '',
    totalHours: '',
    remark: ''
  },

  onLoad(options) {
    this.loadTimeTasks()
  },

  onShow() {
    this.loadTimeTasks()
  },

  onPullDownRefresh() {
    this.loadTimeTasks().then(() => {
      wx.stopPullDownRefresh()
    })
  },

  // 加载计时任务列表
  loadTimeTasks() {
    this.setData({
      loading: true
    })

    return app.userRequest({
      url: '/getTimeTasks'
    }).then((res) => {
      // 检查API返回的状态码
      if (res.code === 0) {
        // API返回失败状态
        throw new Error(res.msg || '获取时间任务失败')
      }
      
      // 按照PC端方式，直接使用返回的数据
      const timeTasks = res.data || []
      this.setData({
        timeTasks: timeTasks,
        loading: false
      })
      
      // 如果没有任务，显示友好提示
      if (timeTasks.length === 0) {
        wx.showToast({
          title: '暂无计时任务',
          icon: 'none',
          duration: 2000
        })
      }
    }).catch((err) => {
      console.error('获取时间任务失败:', err)
      this.setData({
        loading: false
      })
      
      // 显示详细的错误信息
      let errorMsg = '获取时间任务失败'
      if (err.message) {
        errorMsg = err.message
      } else if (err.msg) {
        errorMsg = err.msg
      } else if (err.errMsg) {
        errorMsg = err.errMsg
      }
      
      // 显示错误弹窗，让用户看到具体错误
      wx.showModal({
        title: '加载失败',
        content: errorMsg,
        showCancel: false,
        confirmText: '重试',
        success: (res) => {
          if (res.confirm) {
            // 用户点击重试，重新加载
            this.loadTimeTasks()
          }
        }
      })
    })
  },

  // 开始计时任务
  startTimeTask(e) {
    const taskId = e.currentTarget.dataset.id
    const task = this.data.timeTasks.find(t => t.id == taskId)
    
    if (!task) {
      wx.showToast({
        title: '任务不存在',
        icon: 'none'
      })
      return
    }

    if (task.start_time) {
      wx.showToast({
        title: '任务已经开始',
        icon: 'none'
      })
      return
    }

    this.setData({
      currentTask: task,
      showStartModal: true,
      startTime: this.formatTime(new Date())
    })
  },

  // 结束计时任务
  endTimeTask(e) {
    const taskId = e.currentTarget.dataset.id
    const task = this.data.timeTasks.find(t => t.id == taskId)
    
    if (!task) {
      wx.showToast({
        title: '任务不存在',
        icon: 'none'
      })
      return
    }

    if (!task.start_time) {
      wx.showToast({
        title: '任务尚未开始',
        icon: 'none'
      })
      return
    }

    if (task.end_time) {
      wx.showToast({
        title: '任务已经结束',
        icon: 'none'
      })
      return
    }

    this.setData({
      currentTask: task,
      showEndModal: true,
      endTime: this.formatTime(new Date())
    })
  },

  // 提交计时报工
  submitTimeReport(e) {
    const taskId = e.currentTarget.dataset.id
    const task = this.data.timeTasks.find(t => t.id == taskId)
    
    if (!task) {
      wx.showToast({
        title: '任务不存在',
        icon: 'none'
      })
      return
    }

    if (!task.start_time || !task.end_time) {
      wx.showToast({
        title: '请先开始并结束任务',
        icon: 'none'
      })
      return
    }

    this.setData({
      currentTask: task,
      showReportModal: true,
      totalHours: this.calculateHours(task.start_time, task.end_time)
    })
  },

  // 确认开始计时
  confirmStartTime() {
    const { currentTask, startTime } = this.data
    
    if (!startTime) {
      wx.showToast({
        title: '请选择开始时间',
        icon: 'none'
      })
      return
    }

    app.userRequest({
      url: '/startTimeTask',
      method: 'POST',
      data: {
        task_id: currentTask.id,
        start_time: startTime
      }
    }).then((res) => {
      if (res.code === 0) {
        throw new Error(res.msg || '开始计时失败')
      }
      
      wx.showToast({
        title: '计时开始成功',
        icon: 'success'
      })
      
      this.setData({
        showStartModal: false,
        currentTask: null
      })
      
      // 重新加载任务列表
      this.loadTimeTasks()
    }).catch((err) => {
      wx.showToast({
        title: err.message || '开始计时失败',
        icon: 'none'
      })
    })
  },

  // 确认结束计时
  confirmEndTime() {
    const { currentTask, endTime, totalHours } = this.data
    
    if (!endTime || !totalHours) {
      wx.showToast({
        title: '请填写完整信息',
        icon: 'none'
      })
      return
    }

    if (totalHours <= 0) {
      wx.showToast({
        title: '工时必须大于0',
        icon: 'none'
      })
      return
    }

    app.userRequest({
      url: '/endTimeTask',
      method: 'POST',
      data: {
        task_id: currentTask.id,
        end_time: endTime,
        total_hours: totalHours
      }
    }).then((res) => {
      if (res.code === 0) {
        throw new Error(res.msg || '结束计时失败')
      }
      
      wx.showToast({
        title: '计时结束成功',
        icon: 'success'
      })
      
      this.setData({
        showEndModal: false,
        currentTask: null
      })
      
      // 重新加载任务列表
      this.loadTimeTasks()
    }).catch((err) => {
      wx.showToast({
        title: err.message || '结束计时失败',
        icon: 'none'
      })
    })
  },

  // 确认提交报工
  confirmSubmitReport() {
    const { currentTask, totalHours, remark } = this.data
    
    if (!totalHours || totalHours <= 0) {
      wx.showToast({
        title: '请填写正确的工时',
        icon: 'none'
      })
      return
    }

    app.userRequest({
      url: '/submitTimeReport',
      method: 'POST',
      data: {
        task_id: currentTask.id,
        work_date: currentTask.work_date,
        start_time: currentTask.start_time,
        end_time: currentTask.end_time,
        total_hours: totalHours,
        remark: remark
      }
    }).then((res) => {
      if (res.code === 0) {
        throw new Error(res.msg || '提交报工失败')
      }
      
      wx.showToast({
        title: '报工提交成功',
        icon: 'success'
      })
      
      this.setData({
        showReportModal: false,
        currentTask: null,
        totalHours: '',
        remark: ''
      })
      
      // 重新加载任务列表
      this.loadTimeTasks()
    }).catch((err) => {
      wx.showToast({
        title: err.message || '提交报工失败',
        icon: 'none'
      })
    })
  },

  // 关闭开始计时弹窗
  closeStartModal() {
    this.setData({
      showStartModal: false,
      currentTask: null
    })
  },

  // 关闭结束计时弹窗
  closeEndModal() {
    this.setData({
      showEndModal: false,
      currentTask: null
    })
  },

  // 关闭报工弹窗
  closeReportModal() {
    this.setData({
      showReportModal: false,
      currentTask: null,
      totalHours: '',
      remark: ''
    })
  },

  // 开始时间选择
  onStartTimeChange(e) {
    this.setData({
      startTime: e.detail.value
    })
  },

  // 结束时间选择
  onEndTimeChange(e) {
    this.setData({
      endTime: e.detail.value
    })
  },

  // 工时输入
  onTotalHoursInput(e) {
    this.setData({
      totalHours: e.detail.value
    })
  },

  // 备注输入
  onRemarkInput(e) {
    this.setData({
      remark: e.detail.value
    })
  },

  // 格式化时间为HH:mm格式
  formatTime(date) {
    const hours = String(date.getHours()).padStart(2, '0')
    const minutes = String(date.getMinutes()).padStart(2, '0')
    return `${hours}:${minutes}`
  },

  // 计算工时
  calculateHours(startTime, endTime) {
    if (!startTime || !endTime) return 0
    
    const start = new Date(`2000-01-01 ${startTime}`)
    const end = new Date(`2000-01-01 ${endTime}`)
    
    if (end < start) {
      end.setDate(end.getDate() + 1) // 跨天处理
    }
    
    const diffMs = end - start
    const diffHours = diffMs / (1000 * 60 * 60)
    
    return Math.round(diffHours * 100) / 100 // 保留两位小数
  },

  // 获取状态样式
  getStatusClass(status) {
    switch (status) {
      case 'completed':
        return 'status-completed'
      case 'in_progress':
        return 'status-in-progress'
      case 'pending':
        return 'status-pending'
      default:
        return 'status-pending'
    }
  },

 // 获取状态文本
 getStatusText(status) {
  switch (status) {
    case 'completed':
      return '已完成'
    case 'in_progress':
      return '进行中'
    case 'pending':
      return '待开始'
    default:
      return '待开始'
  }
},

// 跳转到时间报工页面
goToTimeReport(e) {
  const taskId = e.currentTarget.dataset.id
  wx.navigateTo({
    url: `/pages/user-time-report/user-time-report?id=${taskId}`
  })
}
})